// 函数中的类型 对于函数来说我们主要关心的是，函数的入参类型和函数的返回值类型
function sum(a:string,b:string){
    return a+b
}
// 函数的声明方式有两种  funciton关键字来声明   表达式声明
type Sum = (x:string,y:string)=>string
let sum1:Sum= function(a:string,b:string):string{
    return a+b
}
// 或者这样方式
let sum2:{(x:string,y:string):string}=function(a:string,b:string):string{
    return a+b
}
// 泛型不可以进行运行
/* let sum3:<number> =<T>function(a:T,b:T){
    return a+b
} */
// 对于表达式声明而言  我可以给变量重新赋值

// 表达式我们如果给变量写好了一个类型 就意味着我们赋予的值要满足这个类型


// 函数的所有特性  都支持
// ？是针对ts写的
type Sum1 = (x:string,y?:string)=>string
// = 默认值是针对js说的
let sum4:Sum1 =function (a,b = '123'){
    return a + b
}
// 或者
let sum5:Sum1 =function (a:any,b?:string){
    return a + b
}
// 不需要arguments
let sum6 = function (a:string,...args:string[]){
    return args.reduce((memo,current)=>{
       return memo + current
    },a)
}
let r = sum6('a','b','c','d')
console.log(r);
// this问题  this导致的问题是不方便类型推导 用起来麻烦

// typeof取变量的类型  返回的是类型 
//  keyof 取的是类型的key的集合
function getName(this:Person,key:PersonKey){
    return this[key]
}
const person = {name:'js',age:30}
type Person = typeof person
type PersonKey = keyof Person
getName.call(person,'name')


// 函数重载 后端的定义就是定义一些同名的方法  通过定义不同的输入来区分一些方法
// js不支持函数的重载(覆盖) ts也就不支持，所以ts中的函数重载  伪重载

// js是通过arguments来重载

// ‘abc'=>[a,b,c]

// 只能使用函数虫子啊
function toArray(value:number):number[]
function toArray(value:string):string[]
function toArray(value:string | number):string[] | number[]{
    if(typeof value ==='string'){
        return value.split('')
    }else{
        return value.toString().split('').map(Number)
    }
}
let arr1 = toArray(1)
let arr2 = toArray('2')
export{}    